package arraysList;


import java.util.Arrays;

// 顺序表以数组形式进行存储
public class SeqList {
    // 首先创建必要的量：数组、有效数记录、默认数组长度
    public int[] array;
    public int usedSize;
    public static final int DEFAULT_SIZE = 5;

    // 构造方法进行初始化（初始化数组大小，为数组开辟空间）
    public SeqList() {
        array = new int[DEFAULT_SIZE];
    }

    // 不采用以下方法，采用报异常的方式！！
    /*// 检查下标的合法性：不能跳着进行存放
    public boolean isLegal(int pos) {
        if((pos<0)||(pos>usedSize)) {
            return false;
        } else {
            return true;
        }
    }*/

    // 检查下标的合法性：不能跳着进行存放
    // 抛出异常以及自定义异常
    public void isLegal(int pos) {
        if((pos<0)||(pos>usedSize)) {
            throw new PosIndexNotLegalException("下标不合法！");
        }
    }

    // 判断是否满
    public boolean isFull() {
        return (this.usedSize == array.length);
    }

    // 打印顺序表-打印有效位即可
    public void display() {
        /* // 使用for-each进行打印-no-因为会全部打印！！
        for (int x:array) {
            System.out.println(x);
        }*/

        // 尽量使用this！！！
        for (int i = 0; i < this.usedSize; i++) {
            System.out.print(this.array[i] + " ");
        }
        System.out.println();
    }

    // 新增元素,默认在数组最后新增
    public void add(int data) {
        // 判断是否已满
        try {
            if(isFull()) {
                array = Arrays.copyOf(array,-1);
            }
        } catch (NegativeArraySizeException e) {
            e.printStackTrace();
            array = Arrays.copyOf(array,2*array.length); //扩容两倍
        }
        // 在usedSize位置进行元素存储，然后usedSize++
        array[usedSize++] = data;
    }

    // 在 pos 位置新增元素
    public void add(int pos, int data) {
        // 检查pos是否合法--try...catch方式
        // 判断是否满以及扩容
        // 将pos以及之后的位置全部向后挪一位:注意应该从后往前挪！！
        try {
            isLegal(pos);
            if(isFull()) { // 满了就扩容，不需要进行异常抛出
                array = Arrays.copyOf(array,2*array.length);
            }
            for (int i = usedSize-1; i >= pos; i++) {
                array[i+1] =array[i];
            }
            array[pos] = data;
            usedSize++; // 更新有效数据个数
        } catch (PosIndexNotLegalException e) {
            e.printStackTrace();
        }
    }

    // 判定是否包含某个元素
    public boolean contains(int toFind) {
        // 进行遍历
        for (int i = 0; i < usedSize; i++) {
            if(array[i] == toFind) {
                return true;
            }
        }
        return false;
    }

    // 查找某个元素对应的位置
    public int indexOf(int toFind) {
        // 进行遍历
        for (int i = 0; i < usedSize; i++) {
            if(array[i] == toFind) {
                return i;
            }
        }
        return -1; // 不存在就输出-1
    }

    // 获取 pos 位置的元素
    public int get(int pos) {
        // 首先判断pos是否合法
        // 合法且找到才输出元素
        try {
            isLegal(pos);
            return array[pos];
        } catch (PosIndexNotLegalException e) {
            e.printStackTrace();
        }
        return -1;
    }

    // 给 pos 位置的元素设为 value
    public void set(int pos, int value) {
        // 首先进行合法性判断，然后将pos位置的元素进行替换
        try {
            isLegal(pos);
            array[pos] = value;
        } catch (PosIndexNotLegalException e) {
            e.printStackTrace();
        }
    }

    //删除第一次出现的关键字key
    public void remove(int toRemove) {
        // 遍历的方法不容易进行覆盖操作，则改用找该元素的首下标，找到就存在可以进行覆盖，否则不存在不用删除
        /*//遍历
        for (int i = 0; i < usedSize; i++) {
            if(array[i]==toRemove) {
                // 从该项开始进行覆盖，一直到usedSize-1

            }
        }*/

        // 改用找该元素的首下标，找到就存在可以进行覆盖，否则不存在不用删除
        int index = indexOf(toRemove);
        if(index == -1) {
            System.out.println("sorry 该关键字并不存在！");
            return;
        } else {
            // 从该项开始进行覆盖，一直到usedSize-1: 从前往后+usedSize--
            for (int i = index; i < usedSize-1; i++) {
                array[i] = array[i+1];
            }
        }
        // 有效元素--
        usedSize--;
    }

    // 判断是否为空（是否还有有效数）
    public boolean isEmpty() {
        return (usedSize<=0);
    }

    // 获取顺序表长度：有效长度
    public int size() {
        return usedSize;
    }

    // 清空顺序表
    public void clear() {
        /*for (int i = 0; i < usedSize; i++) {
            array[i] = Integer.parseInt(null);
        }*/

        // 将有效个数置0就行
        usedSize = 0;
        System.out.println("清空成功！");
    }

}

